﻿using MemoryViewControl;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.ComponentModel;
using System.Collections.Generic;

namespace TestProject
{
    
    
    /// <summary>
    ///This is a test class for MemorySpaceTest and is intended
    ///to contain all MemorySpaceTest Unit Tests
    ///</summary>
  [TestClass()]
  public class MemorySpaceTest
  {


    private TestContext testContextInstance;

    /// <summary>
    ///Gets or sets the test context which provides
    ///information about and functionality for the current test run.
    ///</summary>
    public TestContext TestContext
    {
      get
      {
        return testContextInstance;
      }
      set
      {
        testContextInstance = value;
      }
    }

    #region Additional test attributes
    // 
    //You can use the following additional attributes as you write your tests:
    //
    //Use ClassInitialize to run code before running the first test in the class
    //[ClassInitialize()]
    //public static void MyClassInitialize(TestContext testContext)
    //{
    //}
    //
    //Use ClassCleanup to run code after all tests in a class have run
    //[ClassCleanup()]
    //public static void MyClassCleanup()
    //{
    //}
    //
    //Use TestInitialize to run code before running each test
    //[TestInitialize()]
    //public void MyTestInitialize()
    //{
    //}
    //
    //Use TestCleanup to run code after each test has run
    //[TestCleanup()]
    //public void MyTestCleanup()
    //{
    //}
    //
    #endregion


    /// <summary>
    ///A test for MemorySpace Constructor
    ///</summary>
    [TestMethod()]
    public void MemorySpaceConstructorTest()
    {
      IContainer container = null; // TODO: Initialize to an appropriate value
      MemorySpace target = new MemorySpace(container);
      Assert.Inconclusive("TODO: Implement code to verify target");
    }

    /// <summary>
    ///A test for MemorySpace Constructor
    ///</summary>
    [TestMethod()]
    public void MemorySpaceConstructorTest1()
    {
      MemorySpace target = new MemorySpace();
      Assert.Inconclusive("TODO: Implement code to verify target");
    }

    /// <summary>
    ///A test for ClearChanged
    ///</summary>
    [TestMethod()]
    public void ClearChangedTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      target.ClearChanged();
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for ClearHidden
    ///</summary>
    [TestMethod()]
    public void ClearHiddenTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      target.ClearHidden();
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for ClearHighlight
    ///</summary>
    [TestMethod()]
    public void ClearHighlightTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      target.ClearHighlight();
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for Cool
    ///</summary>
    [TestMethod()]
    public void CoolTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      float amount = 0F; // TODO: Initialize to an appropriate value
      target.Cool(amount);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for Dispose
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void DisposeTest()
    {
      MemorySpace_Accessor target = new MemorySpace_Accessor(); // TODO: Initialize to an appropriate value
      bool disposing = false; // TODO: Initialize to an appropriate value
      target.Dispose(disposing);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for FindMemory
    ///</summary>
    [TestMethod()]
    public void FindMemoryTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      ushort[] data = null; // TODO: Initialize to an appropriate value
      uint startAddress = 0; // TODO: Initialize to an appropriate value
      uint length = 0; // TODO: Initialize to an appropriate value
      List<MemorySpace.RangeEntry> expected = null; // TODO: Initialize to an appropriate value
      List<MemorySpace.RangeEntry> actual;
      actual = target.FindMemory(data, startAddress, length);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for GetByteSlow
    ///</summary>
    [TestMethod()]
    public void GetByteSlowTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      MemorySpace.ByteInfo expected = new MemorySpace.ByteInfo(); // TODO: Initialize to an appropriate value
      MemorySpace.ByteInfo actual;
      actual = target.GetByteSlow(address);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for GetBytes
    ///</summary>
    [TestMethod()]
    public void GetBytesTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      uint startAddress = 0; // TODO: Initialize to an appropriate value
      MemorySpace.ByteInfo[] bytes = null; // TODO: Initialize to an appropriate value
      MemorySpace.ByteInfo[] bytesExpected = null; // TODO: Initialize to an appropriate value
      target.GetBytes(startAddress, ref bytes);
      Assert.AreEqual(bytesExpected, bytes);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for GetDirtyMemoryRanges
    ///</summary>
    [TestMethod()]
    public void GetDirtyMemoryRangesTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      uint startAddress = 0; // TODO: Initialize to an appropriate value
      uint length = 0; // TODO: Initialize to an appropriate value
      List<MemorySpace.RangeEntry> expected = null; // TODO: Initialize to an appropriate value
      List<MemorySpace.RangeEntry> actual;
      actual = target.GetDirtyMemoryRanges(startAddress, length);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for GetMemorySection
    ///</summary>
    [TestMethod()]
    public void GetMemorySectionTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      MemorySection expected = null; // TODO: Initialize to an appropriate value
      MemorySection actual;
      actual = target.GetMemorySection(address);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for GetMemorySectionAndNext
    ///</summary>
    [TestMethod()]
    public void GetMemorySectionAndNextTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      MemorySection atAddress = null; // TODO: Initialize to an appropriate value
      MemorySection atAddressExpected = null; // TODO: Initialize to an appropriate value
      MemorySection next = null; // TODO: Initialize to an appropriate value
      MemorySection nextExpected = null; // TODO: Initialize to an appropriate value
      target.GetMemorySectionAndNext(address, out atAddress, out next);
      Assert.AreEqual(atAddressExpected, atAddress);
      Assert.AreEqual(nextExpected, next);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for GetNextValidAddress
    ///</summary>
    [TestMethod()]
    public void GetNextValidAddressTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      ulong expected = 0; // TODO: Initialize to an appropriate value
      ulong actual;
      actual = target.GetNextValidAddress(address);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for InitializeComponent
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void InitializeComponentTest()
    {
      MemorySpace_Accessor target = new MemorySpace_Accessor(); // TODO: Initialize to an appropriate value
      target.InitializeComponent();
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for MapRange
    ///</summary>
    [TestMethod()]
    public void MapRangeTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      uint size = 0; // TODO: Initialize to an appropriate value
      string name = string.Empty; // TODO: Initialize to an appropriate value
      int bits = 0; // TODO: Initialize to an appropriate value
      bool expected = false; // TODO: Initialize to an appropriate value
      bool actual;
      actual = target.MapRange(address, size, name, bits);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for OnPropertyChanged
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void OnPropertyChangedTest()
    {
      MemorySpace_Accessor target = new MemorySpace_Accessor(); // TODO: Initialize to an appropriate value
      string propertyName = string.Empty; // TODO: Initialize to an appropriate value
      target.OnPropertyChanged(propertyName);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for OnMemoryChanged
    ///</summary>
    [TestMethod()]
    [DeploymentItem("MemoryViewControl.dll")]
    public void RedrawMemoryTest()
    {
      MemorySpace_Accessor target = new MemorySpace_Accessor(); // TODO: Initialize to an appropriate value
      target.RedrawMemory();
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for SetDirty
    ///</summary>
    [TestMethod()]
    public void SetDirtyTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      target.SetDirty();
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for SetHidden
    ///</summary>
    [TestMethod()]
    public void SetHiddenTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      uint length = 0; // TODO: Initialize to an appropriate value
      bool hidden = false; // TODO: Initialize to an appropriate value
      bool expected = false; // TODO: Initialize to an appropriate value
      bool actual;
      actual = target.SetHidden(address, length, hidden);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for SetHighlight
    ///</summary>
    [TestMethod()]
    public void SetHighlightTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      uint length = 0; // TODO: Initialize to an appropriate value
      int highlight = 0; // TODO: Initialize to an appropriate value
      bool expected = false; // TODO: Initialize to an appropriate value
      bool actual;
      actual = target.SetHighlight(address, length, highlight);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for SetMemoryDirty
    ///</summary>
    [TestMethod()]
    public void SetMemoryDirtyTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      uint size = 0; // TODO: Initialize to an appropriate value
      target.SetMemoryDirty(address, size);
      Assert.Inconclusive("A method that does not return a value cannot be verified.");
    }

    /// <summary>
    ///A test for UpdateBank
    ///</summary>
    [TestMethod()]
    public void UpdateBankTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      uint length = 0; // TODO: Initialize to an appropriate value
      bool expected = false; // TODO: Initialize to an appropriate value
      bool actual;
      actual = target.UpdateBank(address, length);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for UpdateMemory
    ///</summary>
    [TestMethod()]
    public void UpdateMemoryTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      ushort[] data = null; // TODO: Initialize to an appropriate value
      uint length = 0; // TODO: Initialize to an appropriate value
      bool setChanged = false; // TODO: Initialize to an appropriate value
      bool expected = false; // TODO: Initialize to an appropriate value
      bool actual;
      actual = target.UpdateMemory(address, data, length, setChanged);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for UpdateMemory
    ///</summary>
    [TestMethod()]
    public void UpdateMemoryTest1()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      ushort[] data = null; // TODO: Initialize to an appropriate value
      bool setChanged = false; // TODO: Initialize to an appropriate value
      bool expected = false; // TODO: Initialize to an appropriate value
      bool actual;
      actual = target.UpdateMemory(address, data, setChanged);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for UpdateMemory
    ///</summary>
    [TestMethod()]
    public void UpdateMemoryTest2()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      byte[] data = null; // TODO: Initialize to an appropriate value
      bool setChanged = false; // TODO: Initialize to an appropriate value
      bool expected = false; // TODO: Initialize to an appropriate value
      bool actual;
      actual = target.UpdateMemory(address, data, setChanged);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for UpdateMemory
    ///</summary>
    [TestMethod()]
    public void UpdateMemoryTest3()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      byte[] data = null; // TODO: Initialize to an appropriate value
      uint length = 0; // TODO: Initialize to an appropriate value
      bool setChanged = false; // TODO: Initialize to an appropriate value
      bool expected = false; // TODO: Initialize to an appropriate value
      bool actual;
      actual = target.UpdateMemory(address, data, length, setChanged);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for UpdateRead
    ///</summary>
    [TestMethod()]
    public void UpdateReadTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      uint address = 0; // TODO: Initialize to an appropriate value
      uint length = 0; // TODO: Initialize to an appropriate value
      bool expected = false; // TODO: Initialize to an appropriate value
      bool actual;
      actual = target.UpdateRead(address, length);
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for AddressBits
    ///</summary>
    [TestMethod()]
    public void AddressBitsTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      int expected = 0; // TODO: Initialize to an appropriate value
      int actual;
      target.AddressBits = expected;
      actual = target.AddressBits;
      Assert.AreEqual(expected, actual);
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for AddressMax
    ///</summary>
    [TestMethod()]
    public void AddressMaxTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      ulong actual;
      actual = target.AddressMax;
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for AddressNibbles
    ///</summary>
    [TestMethod()]
    public void AddressNibblesTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      int actual;
      actual = target.AddressNibbles;
      Assert.Inconclusive("Verify the correctness of this test method.");
    }

    /// <summary>
    ///A test for AddressValidMax
    ///</summary>
    [TestMethod()]
    public void AddressValidMaxTest()
    {
      MemorySpace target = new MemorySpace(); // TODO: Initialize to an appropriate value
      ulong actual;
      actual = target.AddressValidMax;
      Assert.Inconclusive("Verify the correctness of this test method.");
    }
  }
}
